/**
 * 系统配置模块 - 设备管理功能
 * 处理设备的增删改查操作
 */

// 初始化设备管理模块
function initDeviceManagement() {
    console.log('初始化设备管理模块');
    
    // 先加载设备类型列表，这是其他操作的前提
    loadDeviceTypes();

    // 加载设备列表
    loadDeviceList();

    // 绑定按钮事件
    bindEvents();
}

// 加载设备类型列表
function loadDeviceTypes() {
    try {
        console.log('正在从Android后端加载设备类型列表...');

        // 检查是否使用模拟数据
        if (shouldUseMockData()) {
            console.warn('使用模拟数据模式');
            loadDefaultDeviceTypes();
            return;
        }

        // 使用异步方法获取设备类型
        callAndroidMethodAsync('getDeviceTypeList')
            .then(response => {
                console.log('getDeviceTypeList 获取到响应', response);

                if (!response.success || !response.data) {
                    throw new Error('设备类型数据为空或请求失败');
                }

                let deviceTypes = response.data;

                console.log('设备类型列表:', deviceTypes);

                if (deviceTypes && deviceTypes.length > 0) {
                    console.log('成功加载了', deviceTypes.length, '个设备类型');

                    // 更新添加设备表单中的类型下拉列表
                    updateDeviceTypeDropdown('add-device-type', deviceTypes);

                    // 更新编辑设备表单中的类型下拉列表
                    updateDeviceTypeDropdown('edit-device-type', deviceTypes);
                } else {
                    console.warn('从后端获取的设备类型列表为空，将使用默认值');
                    loadDefaultDeviceTypes();
                }
            })
            .catch(error => {
                console.warn('获取设备类型列表失败，使用默认值:', error);
                loadDefaultDeviceTypes();
            });
    } catch (e) {
        console.error('获取设备类型列表失败:', e);
        showError('获取设备类型列表失败: ' + e.message);
        // 加载失败时使用默认设备类型
        loadDefaultDeviceTypes();
    }
}

// 加载默认设备类型
function loadDefaultDeviceTypes() {
    // 使用mock-data.js中的数据
    if (window.MockData && typeof window.MockData.getAllDeviceTypes === 'function') {
        const deviceTypes = window.MockData.getAllDeviceTypes();
        if (deviceTypes && deviceTypes.length > 0) {
            updateDeviceTypeDropdown('add-device-type', deviceTypes);
            updateDeviceTypeDropdown('edit-device-type', deviceTypes);
            return;
        }
    }

    // 如果模拟数据模块不可用或返回为空，使用简单的备用数据
    const defaultDeviceTypes = window.MockData && window.MockData.deviceTypes;

    updateDeviceTypeDropdown('add-device-type', defaultDeviceTypes);
    updateDeviceTypeDropdown('edit-device-type', defaultDeviceTypes);
}

// 更新设备类型下拉列表
function updateDeviceTypeDropdown(selectId, deviceTypes) {
    const select = document.getElementById(selectId);
    if (!select) return;

    // 清空现有选项
    select.innerHTML = '';

    console.log('更新设备类型下拉列表:', deviceTypes);
    // 添加从Android获取的设备类型
    deviceTypes.forEach(type => {
        const option = document.createElement('option');
        // 使用英文名称作为值，中文名称作为显示文本
        option.value = type.englishName || type.name;
        option.text = type.name;
        // 保存设备类型ID以便在保存和更新时使用
        option.setAttribute('data-id', type.id);
        select.appendChild(option);
    });

    console.log(`已更新${selectId}下拉列表，共${deviceTypes.length}个选项`);
}

// 检查是否应该使用模拟数据
function shouldUseMockData() {
    // 检查是否在Android WebView环境中
    if (!isAndroidWebView()) {
        return true;
    }
    
    // 可以添加其他条件，例如从URL参数或localStorage中获取
    const urlParams = new URLSearchParams(window.location.search);
    if (urlParams.has('mock') && urlParams.get('mock') === 'true') {
        return true;
    }
    
    return false;
}

// 加载设备列表
function loadDeviceList() {
    try {
        console.log('正在获取设备列表...');

        // 显示加载中状态
        const deviceList = document.getElementById('device-list');
        if (deviceList) {
            deviceList.innerHTML = '<div class="empty-list">正在加载设备列表...</div>';
        }

        // 检查是否使用模拟数据
        if (shouldUseMockData()) {
            console.warn('使用模拟数据模式');
            // 使用模拟数据
            const mockDeviceList = getMockDeviceList();
            renderDeviceList(mockDeviceList);
            return;
        }

        // 使用异步方式获取设备列表
        callAndroidMethodAsync('getDeviceList')
            .then(response => {
                console.log('getDeviceList 获取到响应', response);

                if (!response.success || !response.data) {
                    throw new Error('返回数据为空或请求失败');
                }

                let deviceListRaw;

                // 检查返回的数据格式
                if (typeof response.data === 'string') {
                    deviceListRaw = JSON.parse(response.data);
                } else {
                    deviceListRaw = response.data;
                }

                console.log('获取到设备列表:', deviceListRaw);

                // 将Java字段名转换为JavaScript字段名
                const deviceList = deviceListRaw.map(device => {
                    return {
                        id: device.deviceId,
                        name: device.deviceName,
                        ip: device.deviceIp,
                        port: device.devicePort,
                        type: device.deviceType || device.protocol || 'Modbus TCP', // 使用deviceType或fallback到protocol
                        typeId: device.deviceTypeId || 0, // 包含设备类型ID
                        unitId: device.unitId || 1,
                        status: device.isActive ? 'online' : 'offline',
                        description: device.description,
                        lastConnectTime: device.lastConnectTime
                    };
                });

                renderDeviceList(deviceList);
            })
            .catch(error => {
                console.warn('获取设备列表失败:', error);
            });
    } catch (e) {
        console.error('获取设备列表异常:', e);
        showError('获取设备列表失败: ' + e.message);
    }
}

// 获取模拟设备列表数据（用于在浏览器中测试）
function getMockDeviceList() {
    // 使用mock-data.js中的数据
    if (window.MockData && typeof window.MockData.getAllDevices === 'function') {
        return window.MockData.getAllDevices();
    }
    return window.MockData;
}

// 渲染设备列表
function renderDeviceList(deviceList) {
    const deviceListElement = document.getElementById('device-list');
    if (!deviceListElement) return;

    // 清空搜索框
    const searchInput = document.getElementById('device-search');
    if (searchInput) {
        searchInput.value = '';
    }

    // 移除之前的无结果消息
    const emptyMessage = document.querySelector('.no-results-message');
    if (emptyMessage) {
        emptyMessage.remove();
    }

    deviceListElement.innerHTML = '';

    if (deviceList.length === 0) {
        deviceListElement.innerHTML = '<div class="empty-list">暂无设备，请添加</div>';
        return;
    }

    // 获取设备类型映射，用于显示设备类型的中文名称
    const deviceTypeMap = getDeviceTypeMap();

    // 创建表头
    const tableHTML = `
        <table class="device-table">
            <thead>
                <tr>
                    <th>序号</th>
                    <th>IP地址</th>
                    <th>端口</th>
                    <th>类型</th>
                    <th>从站ID</th>
                    <th>状态</th>
                    <th>操作</th>
                </tr>
            </thead>
            <tbody>
                ${deviceList.map((device, index) => {
        // 获取设备类型的显示名称
        let typeDisplay = device.type;
        if (device.typeId && deviceTypeMap[device.typeId]) {
            typeDisplay = deviceTypeMap[device.typeId];
        }

        return `
                    <tr data-id="${device.id}" class="${device.status === 'online' ? 'device-online' : 'device-offline'}">
                        <td>${index + 1}</td>
                        <td>${device.ip}</td>
                        <td>${device.port}</td>
                        <td>${typeDisplay}</td>
                        <td>${device.unitId}</td>
                        <td>${device.status === 'online' ? '在线' : '离线'}</td>
                        <td>
                            <button class="btn-edit" data-id="${device.id}">编辑</button>
                            <button class="btn-delete" data-id="${device.id}">删除</button>
                            <!-- <button class="btn-test" data-id="${device.id}">测试连接</button> -->
                        </td>
                    </tr>
                `}).join('')}
            </tbody>
        </table>
    `;

    deviceListElement.innerHTML = tableHTML;

    // 绑定表格中的按钮事件
    bindTableEvents();
}

// 获取设备类型映射表，用于显示设备类型的中文名称
function getDeviceTypeMap() {
    const typeMap = {};

    // 从添加设备的下拉列表中获取设备类型
    const typeSelect = document.getElementById('add-device-type');
    if (typeSelect) {
        for (let i = 0; i < typeSelect.options.length; i++) {
            const option = typeSelect.options[i];
            const id = parseInt(option.getAttribute('data-id'));
            if (id) {
                typeMap[id] = option.text;
            }
        }
    }

    return typeMap;
}

// 绑定页面按钮事件
function bindEvents() {
    // 添加设备按钮
    const addDeviceBtn = document.getElementById('add-device-btn');
    if (addDeviceBtn) {
        addDeviceBtn.addEventListener('click', showAddDeviceModal);
    }

    // 刷新设备列表按钮
    const refreshBtn = document.getElementById('refresh-device-btn');
    if (refreshBtn) {
        refreshBtn.addEventListener('click', loadDeviceList);
    }

    // 搜索框事件
    const searchInput = document.getElementById('device-search');
    if (searchInput) {
        searchInput.addEventListener('input', filterDeviceList);
    }
}

// 绑定表格中的按钮事件
function bindTableEvents() {
    // 编辑按钮
    document.querySelectorAll('.btn-edit').forEach(btn => {
        btn.addEventListener('click', function () {
            const deviceId = this.getAttribute('data-id');
            editDevice(deviceId);
        });
    });

    // 删除按钮
    document.querySelectorAll('.btn-delete').forEach(btn => {
        btn.addEventListener('click', function () {
            const deviceId = this.getAttribute('data-id');
            deleteDevice(deviceId);
        });
    });

    // 测试连接按钮
    document.querySelectorAll('.btn-test').forEach(btn => {
        btn.addEventListener('click', function () {
            const deviceId = this.getAttribute('data-id');
            testDeviceConnection(deviceId);
        });
    });
}

// 过滤设备列表
function filterDeviceList() {
    const searchInput = document.getElementById('device-search');
    if (!searchInput) return;
    
    const searchTerm = searchInput.value.toLowerCase().trim();
    const deviceRows = document.querySelectorAll('.device-table tbody tr');
    
    if (deviceRows.length === 0) return;
    
    let hasVisibleRow = false;
    
    // 遍历设备行并过滤
    deviceRows.forEach(row => {
        // 现在只使用IP地址进行过滤
        const deviceIp = row.querySelector('td:nth-child(2)').innerText.toLowerCase();
        const deviceType = row.querySelector('td:nth-child(4)').innerText.toLowerCase();
        
        if (deviceIp.includes(searchTerm) || deviceType.includes(searchTerm) || searchTerm === '') {
            row.style.display = '';
            hasVisibleRow = true;
        } else {
            row.style.display = 'none';
        }
    });
    
    // 如果没有匹配的行，显示无结果消息
    const emptyMessage = document.querySelector('.no-results-message');
    if (!hasVisibleRow) {
        if (!emptyMessage) {
            const deviceList = document.getElementById('device-list');
            const noResultsDiv = document.createElement('div');
            noResultsDiv.className = 'empty-list no-results-message';
            noResultsDiv.innerHTML = '没有找到匹配的设备';
            deviceList.appendChild(noResultsDiv);
        } else {
            emptyMessage.style.display = '';
        }
    } else if (emptyMessage) {
        emptyMessage.style.display = 'none';
    }
}

// 获取设备表单字段配置
function getDeviceFormFields(deviceData = {}) {
    return [
        // 移除设备名称字段
        {
            name: 'deviceIp',
            label: 'IP地址',
            type: 'text',
            required: true,
            value: deviceData.ip || '192.168.0.1'
        },
        {
            name: 'devicePort',
            label: '端口号',
            type: 'number',
            required: true,
            value: deviceData.port || '502'
        },
        {
            name: 'deviceType',
            label: '设备类型',
            type: 'select',
            required: true,
            options: getDeviceTypeOptions(),
            value: deviceData.type || (getDeviceTypeOptions()[0] ? getDeviceTypeOptions()[0].value : ''),
            noDefaultOption: true // 不显示默认的"请选择"选项
        },
        {
            name: 'unitId',
            label: '从站ID',
            type: 'number',
            required: false,
            value: deviceData.unitId || '1'
        }
    ];
}

// 显示添加设备的模态框
function showAddDeviceModal() {
    // 先确保设备类型已加载
    if (!document.getElementById('add-device-type').options.length) {
        loadDeviceTypes();
    }
    
    // 获取当前主题
    const currentTheme = document.documentElement.getAttribute('data-theme') || 'default';
    
    // 使用通用表单模态框
    const modal = showFormModal({
        title: '添加设备',
        fields: getDeviceFormFields(),
        submitText: '添加',
        cancelText: '取消',
        layout: 'double', // 使用双列布局
        onSubmit: function(formData) {
            console.log("表单提交回调被触发", formData);
            
            // 自动使用设备类型作为设备名称
            const deviceTypeOptions = getDeviceTypeOptions();
            const selectedType = deviceTypeOptions.find(opt => opt.value === formData.deviceType);
            
            // 设置设备名称为设备类型的显示名称
            formData.deviceName = selectedType ? selectedType.text : formData.deviceType;
            console.log("自动使用设备类型作为设备名称:", formData.deviceName);
            
            saveDevice(formData);
        }
    });
    
    // 确保模态框应用当前主题
    if (modal && modal.classList) {
        modal.classList.add(`theme-${currentTheme}`);
    }
    
    console.log("添加设备模态框已创建");
}

// 获取设备类型选项
function getDeviceTypeOptions() {
    const options = [];
    const typeSelect = document.getElementById('add-device-type');
    if (typeSelect) {
        console.log("typeSelect", typeSelect);
        for (let i = 0; i < typeSelect.options.length; i++) {
            const option = typeSelect.options[i];
            if (option.value) {
                options.push({
                    value: option.value,
                    text: option.text,
                    deviceTypeId: option.getAttribute('data-id') || '0'
                });
            }
        }
    }
    return options;
}

// 保存设备信息
function saveDevice(formData) {
    try {
        // 表单验证
        if (!formData.deviceName || !formData.deviceIp || !formData.devicePort) {
            showInfoDialog('请填写完整的设备信息', 'warning');
            return;
        }

        console.log('保存设备:', formData);

        // 构造设备数据 - 转换为Java端使用的字段名
        const javaDeviceData = {
            deviceName: formData.deviceName,
            deviceIp: formData.deviceIp,
            devicePort: parseInt(formData.devicePort),
            deviceType: formData.deviceType,
            deviceTypeId: parseInt(formData.deviceTypeId) || 0,
            unitId: parseInt(formData.unitId) || 1
        };

        // 检查是否使用模拟数据
        if (shouldUseMockData()) {
            console.warn('使用模拟数据模式');
            // 添加模拟数据刷新列表
            const mockList = getMockDeviceList();
            mockList.push({
                id: mockList.length + 1,
                name: formData.deviceName,
                ip: formData.deviceIp,
                port: formData.devicePort,
                type: formData.deviceType,
                status: 'offline'
            });
            renderDeviceList(mockList);

            // 关闭模态框
            closeModal();
            return;
        }

        // 使用异步方法调用Android接口保存设备
        callAndroidMethodAsync('addDevice', javaDeviceData)
            .then(response => {
                if (response.success) {
                    // 成功时不显示提示，直接刷新列表
                    loadDeviceList(); // 重新加载设备列表

                    // 关闭模态框
                    closeModal();
                } else {
                    showInfoDialog('设备添加失败: ' + response.message, 'error');
                }
            })
            .catch(error => {
                console.warn('保存设备API调用失败，使用模拟数据:', error);

                // 添加模拟数据刷新列表
                const mockList = getMockDeviceList();
                mockList.push({
                    id: mockList.length + 1,
                    name: formData.deviceName,
                    ip: formData.deviceIp,
                    port: formData.devicePort,
                    type: formData.deviceType,
                    status: 'offline'
                });
                renderDeviceList(mockList);

                // 关闭模态框
                closeModal();
            });
    } catch (e) {
        console.error('保存设备失败:', e);
        showInfoDialog('保存设备失败: ' + e.message, 'error');
    }
}

// 编辑设备
function editDevice(deviceId) {
    try {
        console.log('获取设备详情, ID:', deviceId);
        
        // 检查是否使用模拟数据
        if (shouldUseMockData()) {
            console.warn('使用模拟数据模式');
            const mockDevice = window.MockData.getDeviceById(deviceId);
            if (!mockDevice) {
                showInfoDialog('获取设备详情失败', 'error');
                return;
            }
            
            showEditDeviceModal(mockDevice);
            return;
        }
        
        // 使用异步方法获取设备详情
        callAndroidMethodAsync('getDeviceById', deviceId)
            .then(response => {
                if (!response.success || !response.data) {
                    throw new Error('设备数据为空或请求失败');
                }
                
                let deviceRaw;
                if (typeof response.data === 'string') {
                    deviceRaw = JSON.parse(response.data);
                    } else {
                    deviceRaw = response.data;
                }
                
                // 转换设备数据格式
                const deviceData = {
                    id: deviceRaw.deviceId,
                    name: deviceRaw.deviceName,
                    ip: deviceRaw.deviceIp,
                    port: deviceRaw.devicePort,
                    type: deviceRaw.deviceType || deviceRaw.protocol,
                    typeId: deviceRaw.deviceTypeId || 0,
                    unitId: deviceRaw.unitId || 1,
                    status: deviceRaw.isActive ? 'online' : 'offline',
                    description: deviceRaw.description
                };
                
                showEditDeviceModal(deviceData);
            })
            .catch(error => {
                console.warn('获取设备详情失败:', error);
                showInfoDialog('获取设备详情失败: ' + error.message, 'error');
            });
    } catch (e) {
        console.error('编辑设备异常:', e);
        showInfoDialog('编辑设备失败: ' + e.message, 'error');
    }
}

// 显示编辑设备模态框
function showEditDeviceModal(deviceData) {
    // 获取当前主题
    const currentTheme = document.documentElement.getAttribute('data-theme') || 'default';
    
    const modal = showFormModal({
        title: '编辑设备',
        fields: getDeviceFormFields(deviceData),
        data: {
            id: deviceData.id
        },
        submitText: '更新',
        cancelText: '取消',
        layout: 'double', // 使用双列布局
        onSubmit: function(formData) {
            console.log("编辑表单提交回调被触发", formData);
            
            // 自动使用设备类型作为设备名称
            const deviceTypeOptions = getDeviceTypeOptions();
            const selectedType = deviceTypeOptions.find(opt => opt.value === formData.deviceType);
            
            // 设置设备名称为设备类型的显示名称
            formData.deviceName = selectedType ? selectedType.text : formData.deviceType;
            console.log("自动使用设备类型作为设备名称:", formData.deviceName);
            
            updateDevice(deviceData.id, formData);
        }
    });
    
    // 确保模态框应用当前主题
    if (modal && modal.classList) {
        modal.classList.add(`theme-${currentTheme}`);
    }
    
    console.log("编辑设备模态框已创建");
}

// 更新设备信息
function updateDevice(deviceId, formData) {
    try {
        // 表单验证
        if (!formData.deviceName || !formData.deviceIp || !formData.devicePort) {
            showInfoDialog('请填写完整的设备信息', 'warning');
            return;
        }

        console.log('更新设备:', deviceId, formData);

        // 构造更新数据
        const updateData = {
            deviceId: deviceId,
            deviceName: formData.deviceName,
            deviceIp: formData.deviceIp,
            devicePort: parseInt(formData.devicePort),
            deviceType: formData.deviceType,
            deviceTypeId: parseInt(formData.deviceTypeId) || 0,
            unitId: parseInt(formData.unitId) || 1
        };

        // 检查是否使用模拟数据
        if (shouldUseMockData()) {
            console.warn('使用模拟数据模式');
            loadDeviceList(); // 重新加载设备列表
            closeModal(); // 关闭模态框
            return;
        }

        // 使用异步方法调用Android接口
        callAndroidMethodAsync('updateDevice', updateData)
            .then(response => {
                if (response.success) {
                    loadDeviceList(); // 重新加载设备列表
                    closeModal(); // 关闭模态框
                } else {
                    showInfoDialog('设备更新失败: ' + response.message, 'error');
                }
            })
            .catch(error => {
                console.warn('更新设备API调用失败，使用模拟数据:', error);
                loadDeviceList(); // 重新加载设备列表
                closeModal(); // 关闭模态框
            });
    } catch (e) {
        console.error('更新设备失败:', e);
        showInfoDialog('更新设备失败: ' + e.message, 'error');
    }
}

// 删除设备
function deleteDevice(deviceId) {
    try {
        // 获取设备信息用于确认对话框
        const deviceRow = document.querySelector(`tr[data-id="${deviceId}"]`);
        let deviceInfo = `设备 ${deviceId}`;
        
        if (deviceRow) {
            const deviceIp = deviceRow.cells[1].textContent;
            const deviceType = deviceRow.cells[3].textContent;
            deviceInfo = `${deviceType} (${deviceIp})`;
        }
        
        console.log("准备删除设备:", deviceId, deviceInfo);
        
        // 获取当前主题
        const currentTheme = document.documentElement.getAttribute('data-theme') || 'default';
        
        // 显示确认对话框
        const confirmModal = showConfirmDialog({
            title: '删除确认',
            message: `确定要删除设备"${deviceInfo}"吗？此操作不可撤销。`,
            confirmText: '删除',
            cancelText: '取消',
            onConfirm: function() {
                console.log("删除确认回调被触发");
                performDeleteDevice(deviceId, deviceInfo);
            },
            onCancel: function() {
                console.log("删除取消");
            }
        });
        
        // 确保模态框应用当前主题
        if (confirmModal && confirmModal.classList) {
            confirmModal.classList.add(`theme-${currentTheme}`);
        }
        
        console.log("删除确认对话框已创建");
    } catch (e) {
        console.error('删除设备异常:', e);
        showInfoDialog('删除设备失败: ' + e.message, 'error');
    }
}

// 执行删除设备操作
function performDeleteDevice(deviceId, deviceInfo) {
    try {
        console.log('删除设备:', deviceId, deviceInfo);
        
        // 检查是否使用模拟数据
        if (shouldUseMockData()) {
            console.warn('使用模拟数据模式');
            loadDeviceList(); // 重新加载设备列表
            return;
        }
        
        // 使用异步方法调用Android接口
        callAndroidMethodAsync('deleteDevice', { deviceId: deviceId })
            .then(response => {
                if (response.success) {
                    loadDeviceList(); // 重新加载设备列表
                } else {
                    showInfoDialog('设备删除失败: ' + response.message, 'error');
                }
            })
            .catch(error => {
                console.warn('删除设备API调用失败，使用模拟数据:', error);
                loadDeviceList(); // 重新加载设备列表
            });
    } catch (e) {
        console.error('删除设备失败:', e);
        showInfoDialog('删除设备失败: ' + e.message, 'error');
    }
}

// 测试设备连接
function testDeviceConnection(deviceId) {
    try {
        console.log('开始测试设备连接:', deviceId);

        // 检查是否使用模拟数据
        if (shouldUseMockData()) {
            console.warn('使用模拟数据模式');
            const isSuccess = Math.random() > 0.5; // 50%成功率
            if (!isSuccess) {
                showInfoDialog('设备连接测试失败：连接超时', 'error');
            }
            return;
        }

        // 使用异步方法调用Android接口
        console.log('调用Android接口测试连接:', deviceId);
        callAndroidMethodAsync('testDeviceConnection', { deviceId: deviceId })
            .then(response => {
                console.log('测试连接响应:', response);
                if (!response.success) {
                    showInfoDialog('设备连接测试失败: ' + response.message, 'error');
                }
            })
            .catch(error => {
                console.error('测试设备连接API调用失败:', error);
                showInfoDialog('设备连接测试失败: ' + error.message, 'error');
            });
    } catch (e) {
        console.error('测试设备连接异常:', e);
        showInfoDialog('设备连接测试失败: ' + e.message, 'error');
    }
} 